Введите слово или словосочетание на любом языке 👆
Язык:
Перевод и анализ слов искусственным интеллектом ChatGPT
На этой странице Вы можете получить подробный анализ слова или словосочетания, произведенный с помощью лучшей на сегодняшний день технологии искусственного интеллекта:
- как употребляется слово
- частота употребления
- используется оно чаще в устной или письменной речи
- варианты перевода слова
- примеры употребления (несколько фраз с переводом)
- этимология
Что (кто) такое evaluation strategy - определение
STRATEGY USED BY PROGRAMMING LANGUAGES TO DETERMINE TWO THINGS—WHEN TO EVALUATE THE ARGUMENTS OF A FUNCTION CALL AND WHAT KIND OF VALUE TO PASS TO THE FUNCTION
Eager evaluation; Call-by-something; Call by reference; Call By Reference; Call by value; Call by something; Call by name; Strict evaluation; Cbpv; Call-by-name; Call-by-need; Call-by-value; Call-by-result; Call-by-reference; Call by result; Call-by-value-result; Call by Name; Pass-by-reference; Return-by-reference; Comparison of normal-order evaluation and applicative-order evaluation; Applicative-order evaluation; Normal-order evaluation; Applicative order; Applicative order evaluation; Normal order evaluation; Non-strict evaluation; Pass by reference; Pass-by-value; Non-strict semantics; Eager execution; Lazy language; Avaliação ansiosa; Avaliacao ansiosa; Call by value-result; Call by value result; Call by value/result; Pass by value; Pass By Value; Pass-By-Value; Pass By Reference; Pass-By-Reference; Pass By Name; Pass-By-Name; Pass-By-Value Evaluation; Pass-By-Reference Evaluation; Pass-By-Name Evaluation; Call-By-Value Evaluation; Call-By-Reference Evaluation; All-By-Name Evaluation; Normal order reduction; Call by object; Call-by-object; Called by value; Call by sharing; Call by future; Call-by-sharing; Call by copy-restore; Call by address; Call by macro expansion; Greedy evaluation
Найдено результатов: 808
evaluation strategy
Evaluation strategy
In a programming language, an evaluation strategy is a set of rules for evaluating expressions. The term is often used to refer to the more specific notion of a parameter-passing strategy that defines the kind of value that is passed to the function for each parameter (the binding strategy) and whether to evaluate the parameters of a function call, and if so in what order (the evaluation order).
strict evaluation
Call-by-value evaluation order is sometimes called "strict
evaluation" because, in a sequential system, it makes
functions behave as though they were strict, in the sense
that evaluation of a function application cannot terminate
before evaluation of the argument. Similarly, languages are
called strict if they use call-by-value argument passing.
Compare eager evaluation, lazy evaluation.
(1994-12-21)
call-by-value
(CBV) An evaluation strategy where arguments are evaluated
before the function or procedure is entered. Only the values
of the arguments are passed and changes to the arguments
within the called procedure have no effect on the actual
arguments as seen by the caller. See {applicative order
reduction}, call-by-value-result, strict evaluation,
call-by-name, lazy evaluation.
call-by-reference
<programming> An argument passing convention where the
address of an argument variable is passed to a function or
procedure, as opposed to passing the value of the argument
expression. Execution of the function or procedure may have
side-effects on the actual argument as seen by the caller.
The C language's "&" (address of) and "*" (dereference)
operators allow the programmer to code explicit
call-by-reference. Other languages provide special syntax to
declare reference arguments (e.g. ALGOL 60).
See also call-by-name, call-by-value,
call-by-value-result.
(2006-05-27)
call-by-name
<reduction> (CBN) (Normal order reduction, leftmost, outermost
reduction). An argument passing convention (first provided
by ALGOL 60?) where argument expressions are passed
unevaluated. This is usually implemented by passing a pointer
to a thunk - some code which will return the value of the
argument and an environment giving the values of its {free
variables}.
This evaluation strategy is guaranteed to reach a {normal
form} if one exists.
When used to implement functional programming languages,
call-by-name is usually combined with graph reduction to
avoid repeated evaluation of the same expression. This is
then known as call-by-need.
The opposite of call-by-name is call-by-value where
arguments are evaluated before they are passed to a function.
This is more efficient but is less likely to terminate in the
presence of infinite data structures and recursive
functions.
Arguments to macros are usually passed using call-by-name.
(2006-05-27)
call-by-need
<reduction> A reduction strategy which delays evaluation of
function arguments until their values are needed. A value
is needed if it is an argument to a primitive function or it
is the condition in a conditional. Call-by-need is one
aspect of lazy evaluation.
The term first appears in Chris Wadsworth's thesis "Semantics
and Pragmatics of the Lambda calculus" (Oxford, 1971, p. 183).
It was used later, by J. Vuillemin in his thesis (Stanford,
1973).
(1995-05-27)
eager evaluation
Any evaluation strategy where evaluation of some or all
function arguments is started before their value is required.
A typical example is call-by-value, where all arguments are
passed evaluated. The opposite of eager evaluation is
call-by-need where evaluation of an argument is only started
when it is required.
The term "speculative evaluation" is very close in meaning
to eager evaluation but is applied mostly to parallel
architectures whereas eager evaluation is used of both
sequential and parallel evaluators.
Eager evaluation does not specify exactly when argument
evaluation takes place - it might be done fully speculatively
(all redexes in the program reduced in parallel) or may be
done by the caller just before the function is entered.
The term "eager evaluation" was invented by Carl Hewitt and
Henry Baker <hbaker@netcom.com> and used in their paper ["The
Incremental Garbage Collection of Processes", Sigplan Notices,
Aug 1977.
ftp://ftp.netcom.com/pub/hb/hbaker/Futures.html]. It was
named after their "eager beaver" evaluator.
See also conservative evaluation, lenient evaluation,
strict evaluation.
(1994-12-22)
normal order reduction
Under this evaluation strategy an expression is evaluated by
reducing the leftmost outermost redex first. This method
will terminate for any expression for which termination is
possible, whereas applicative order reduction may not. This
method is equivalent to passing arguments unevaluated because
arguments are initially to the right of functions applied to
them. See also computational adequacy theorem.
call-by-value-result
An argument passing convention where the actual argument is
a variable V whose value is copied to a local variable L
inside the called function or procedure. If the procedure
modifies L, these changes will not affect V, which may also be
in scope inside the procedure, until the procedure returns
when the final value of L is copied to V. Under
call-by-reference changes to L would affect V immediately.
Used, for example, by BBC BASIC V on the Acorn
Archimedes.
Википедия
Evaluation strategy
In a programming language, an evaluation strategy is a set of rules for evaluating expressions. The term is often used to refer to the more specific notion of a parameter-passing strategy that defines the kind of value that is passed to the function for each parameter (the binding strategy) and whether to evaluate the parameters of a function call, and if so in what order (the evaluation order). The notion of reduction strategy is distinct, although some authors conflate the two terms and the definition of each term is not widely agreed upon.
To illustrate, executing a function call f(a,b) may first evaluate the arguments a and b, store the results in references or memory locations ref_a and ref_b, then evaluate the function's body with those references passed in. This gives the function the ability to look up the argument values, to modify them via assignment as if they were local variables, and to return values via the references. This is the call-by-reference evaluation strategy.
Evaluation strategy is part of the semantics of the programming language definition. Some languages, such as PureScript, have variants with different evaluation strategies. Some declarative languages, such as Datalog, support multiple evaluation strategies. Some languages define a calling convention.
